{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Twin Delated DDPG  (TD3) with PyTorch\n",
    "\n",
    "In this notebook we will look at Twin Delayed Deep Deterministic Policy Gradient (TD3) algorithm using PyTorch. It builds on what we saw in `listing8_1` for DDPG. \n",
    "\n",
    "Click here to access the paper which proposed TD3: https://arxiv.org/pdf/1802.09477.pdf\n",
    "\n",
    "TD3 is an improvement over DDPG with following changes:\n",
    "\n",
    "1) \"Twin\" - Uses clipped double Q-learning. TD3 learns two q-functions (\"twin\") and uses smaller of the two to computer bellman errors `q_target = min(q1_target, q2_target)`\n",
    "\n",
    "2) \"Delayed\" - policy updates are done at a frequency slower than Q-updates. Usually policy is updated every 2 steps of q-update.\n",
    "\n",
    "3) Target Policy smoothing - TD3 adds noise to target actions \n",
    "\n",
    "\n",
    "The basic premise is same as DDPG. TD3 is a variation of DDPG which in turn is a variation of Q-Learning with continuous action functions. When we have discrete functions, we learn Q-function for a given state and all possible actions. We then pick the best action and Q-value using `max` over all values: Q(s,a), a is all possible actions. \n",
    "\n",
    "$$a^*(s) = arg \\underset{a}{max} Q^*(s,a)$$ \n",
    "\n",
    "However, when action is continuous, we cannot find the max so easily. It becomes an optimization problem with significant costs as we have to find the max at every step.\n",
    "\n",
    "In TD3 we learn three networks, one is a policy network which takes state as input and learns to output the policy/action. Other two networks learn the Q function. However, unlike Q-learning of past, it takes state and actions as inputs and produces Q-value as output. \n",
    "\n",
    "TD# is also an off-policy. Like DDPG we use ReplayBuffer to collect the transitions and iterate over a batch to do gradient update for the policy(Actor) and Q-value(Critic) networks. \n",
    "\n",
    "Like Q-Learning, we also use target networks, both for policy as well as Q-value. The target networks are updated using polyak averaging. The complete Algorithm is as given below:\n",
    "\n",
    "***\n",
    "**Twin Delayed DDPG (TD3)**\n",
    "***\n",
    " \n",
    "1. Input initial policy parameters $\\theta$,  Q-function parameters $\\phi_1$ and $\\phi_2$, empty replay buffer D\n",
    "\n",
    "2. Set target parameters equal to online parameters $\\theta_{targ} \\leftarrow \\theta$, $\\phi_{targ,1} \\leftarrow \\phi_1$ and $\\phi_{targ,2} \\leftarrow \\phi_2$\n",
    "\n",
    "3. **repeat**\n",
    "\n",
    "4. Observe state s and select action $a = clip(\\mu_\\theta(s)+\\epsilon, a_{Low}, a_{High}), \\text{where  } \\epsilon \\sim N$\n",
    "\n",
    "5. Execute a in environment and observe next state s', reward r, and done signal d\n",
    "\n",
    "6. Store `(s,a,r,s',d)` in Replay Buffer D\n",
    "\n",
    "7. if `s'` is terminal state, reset the environment\n",
    "\n",
    "8. if it's time to update **then**:\n",
    "\n",
    "9. &emsp;&emsp;for j in range (as many updates as required):\n",
    "\n",
    "10. &emsp;&emsp;&emsp;&emsp;Sample a batch B={`(s,a,r,s',d)`} from replay Buffer D:\n",
    "\n",
    "11. &emsp;&emsp;&emsp;&emsp;Compute target actions:\n",
    "\n",
    "$$a'(s') = \\text{clip}\\left(\\mu_{\\theta_{\\text{targ}}}(s') + \\text{clip}(\\epsilon,-c,c), a_{Low}, a_{High}\\right), \\;\\;\\;\\;\\; \\epsilon \\sim \\mathcal{N}(0, \\sigma)$$\n",
    "\n",
    "12. &emsp;&emsp;&emsp;&emsp;Compute action targets: \n",
    "\n",
    "$$y(r,s',d) = r + \\gamma (1-d) \\min_{i=1,2} Q_{\\phi_{\\text{targ},i}}(s', a'(s'))$$\n",
    "\n",
    "13. &emsp;&emsp;&emsp;&emsp;Update Q function with one step gradient descent on $\\phi$: \n",
    "$$\\nabla_\\phi \\frac{1}{|B|} \\sum_{(s,a,r,s',d)\\in B}(Q_{\\phi_i}(s,a) - y(r,s',d))^2, \\;\\;\\;\\;\\;  \\text{for } i=1,2$$\n",
    "\n",
    "14. &emsp;&emsp;&emsp;&emsp;if `j mod policy_update == 0`:\n",
    "\n",
    "15. &emsp;&emsp;&emsp;&emsp;&emsp;&emsp;Update Policy with one step gradient Ascent on $\\theta$: \n",
    "\n",
    "$$\\nabla_\\theta \\frac{1}{|B|} \\sum_{s \\in B} Q_{\\phi_1}(s, \\mu_\\phi(s, \\mu_\\theta(s))$$\n",
    "\n",
    "16. &emsp;&emsp;&emsp;&emsp;&emsp;&emsp;Update target networks using polyak averaging: \n",
    "$$\\phi_{targ,i} \\leftarrow \\rho\\phi_{targ,i} + (1-\\rho)\\phi_i, \\;\\;\\;\\;\\;  \\text{for } i=1,2$$ \n",
    "$$\\theta_{targ} \\leftarrow \\rho\\theta_{targ} + (1-\\rho)\\theta$$\n",
    "***\n",
    "\n",
    "\n",
    "#### Key Features of TD3\n",
    "Similar to DDPG:\n",
    "1. TD3 is an off-policy algorithm.\n",
    "2. TD3 can only be used for environments with continuous action spaces.\n",
    "3. TD3 can be thought of as being deep Q-learning for continuous action spaces.\n",
    "\n",
    "\n",
    "\n",
    "#### Our Implementation\n",
    "THis notebook follows the code found in OpenAI's [Spinning Up Library](https://spinningup.openai.com/en/latest/algorithms/td3.html). In this notebook we have broken the code into separate code cells with required explanations. Also some of the implementations like ReplayBuffer have been borrowed from our past notebooks to provide continuity. Further some codes like building of networks have been simplified resulting in easier to understand but more verbose code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.signal\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.optim import Adam\n",
    "\n",
    "from copy import deepcopy\n",
    "import gym\n",
    "\n",
    "\n",
    "import os\n",
    "import io\n",
    "import base64\n",
    "import time\n",
    "import glob\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - Pendulum\n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are continuous. We will build it on `Pendulum-v0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name, seed=None):\n",
    "    # remove time limit wrapper from environment\n",
    "    env = gym.make(env_name).unwrapped\n",
    "    if seed is not None:\n",
    "        env.seed(seed)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State shape: (3,)\n",
      "Action shape: (1,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'Pendulum-v0'\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset()\n",
    "plt.imshow(env.render(\"rgb_array\"))\n",
    "state_shape, action_shape = env.observation_space.shape, env.action_space.shape\n",
    "print('State shape: {}'.format(state_shape))\n",
    "print('Action shape: {}'.format(action_shape))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Policy network (Actor)\n",
    "It is a simple 2 hidden layer network which takes state as input and produces action making sure that action values are within the allowed range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPActor(nn.Module):\n",
    "    def __init__(self, state_dim, act_dim, act_limit):\n",
    "        super().__init__()\n",
    "        self.act_limit = act_limit\n",
    "        self.fc1 = nn.Linear(state_dim, 256)\n",
    "        self.fc2 = nn.Linear(256, 256)\n",
    "        self.actor = nn.Linear(256, act_dim)\n",
    "    \n",
    "    def forward(self, s):\n",
    "        x = self.fc1(s)\n",
    "        x = F.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.actor(x)\n",
    "        x = torch.tanh(x)  # to output in range(-1,1)\n",
    "        x = self.act_limit * x\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Q-network network (Critic)\n",
    "It is a simple 2 hidden layer network which takes state and action as input and produces Q-value as output. We will have two versions of Q-network as Critic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPQFunction(nn.Module):\n",
    "    def __init__(self, state_dim, act_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(state_dim+act_dim, 256)\n",
    "        self.fc2 = nn.Linear(256, 256)\n",
    "        self.Q = nn.Linear(256, 1)\n",
    "    \n",
    "    def forward(self, s, a):\n",
    "        x = torch.cat([s,a], dim=-1)\n",
    "        x = self.fc1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = F.relu(x)\n",
    "        q = self.Q(x)\n",
    "        return torch.squeeze(q, -1)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combine Actor and Critic into a single model\n",
    "\n",
    "One policy Network and Two Q-networks as discussed above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPActorCritic(nn.Module):\n",
    "    def __init__(self, observation_space, action_space):\n",
    "        super().__init__()\n",
    "        self.state_dim = observation_space.shape[0]\n",
    "        self.act_dim = action_space.shape[0]\n",
    "        self.act_limit = action_space.high[0]\n",
    "        \n",
    "        #build Q and policy functions\n",
    "        self.q1 = MLPQFunction(self.state_dim, self.act_dim)\n",
    "        self.q2 = MLPQFunction(self.state_dim, self.act_dim)\n",
    "        self.policy = MLPActor(self.state_dim, self.act_dim, self.act_limit)\n",
    "        \n",
    "    def act(self, state):\n",
    "        with torch.no_grad():\n",
    "            return self.policy(state).numpy()\n",
    "\n",
    "    def get_action(self, s, noise_scale):\n",
    "        a = self.act(torch.as_tensor(s, dtype=torch.float32))\n",
    "        a += noise_scale * np.random.randn(self.act_dim)\n",
    "        return np.clip(a, -self.act_limit, self.act_limit)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon-greedy$) to sample from the environment and store the transitions (s,a,r,s',done) into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size=1e6):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "            self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size=32):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q-loss\n",
    "\n",
    "Compute Q-loss as per equations:\n",
    "\n",
    "$$a'(s') = \\text{clip}\\left(\\mu_{\\theta_{\\text{targ}}}(s') + \\text{clip}(\\epsilon,-c,c), a_{Low}, a_{High}\\right), \\;\\;\\;\\;\\; \\epsilon \\sim \\mathcal{N}(0, \\sigma)$$\n",
    "\n",
    "$$y(r,s',d) = r + \\gamma (1-d) \\min_{i=1,2} Q_{\\phi_{\\text{targ},i}}(s', a'(s'))$$\n",
    "\n",
    " \n",
    "$$Q_{Loss, i} = \\frac{1}{|B|} \\sum_{(s,a,r,s',d)\\in B}(Q_{\\phi_i}(s,a) - y(r,s',d))^2, \\;\\;\\;\\;\\;$$\n",
    "\n",
    "$$Q_{Loss} = \\sum_{i=1,2} Q_{Loss, i}$$\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def compute_q_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma, target_noise, noise_clip, act_limit):\n",
    "    \n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, dtype=torch.float)\n",
    "    rewards = torch.tensor(rewards, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),dtype=torch.float)\n",
    "    \n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    q1 = agent.q1(states, actions)\n",
    "    q2 = agent.q2(states, actions)\n",
    "    \n",
    "    # Bellman backup for Q function\n",
    "    with torch.no_grad():\n",
    "        \n",
    "        action_target = target_network.policy(next_states)\n",
    "        \n",
    "        # Target policy smoothing\n",
    "        epsilon = torch.randn_like(action_target) * target_noise\n",
    "        epsilon = torch.clamp(epsilon, -noise_clip, noise_clip)\n",
    "        action_target = action_target + epsilon\n",
    "        action_target = torch.clamp(action_target, -act_limit, act_limit)\n",
    "            \n",
    "            \n",
    "        q1_target = target_network.q1(next_states, action_target)\n",
    "        q2_target = target_network.q2(next_states, action_target)\n",
    "        q_target = torch.min(q1_target, q2_target) \n",
    "        target = rewards + gamma * (1 - done_flags) * q_target\n",
    "\n",
    "    # MSE loss against Bellman backup\n",
    "    loss_q1 = ((q1 - target)**2).mean()\n",
    "    loss_q2 = ((q2 - target)**2).mean()\n",
    "    loss_q = loss_q1 + loss_q2\n",
    "    \n",
    "    return loss_q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Policy-Loss\n",
    "\n",
    "Compute Policy Loss as per equation:\n",
    "    \n",
    "$$Policy_{Loss} = - \\frac{1}{|B|} \\sum_{s \\in B} Q_{\\phi_1}(s, \\mu_\\phi(s, \\mu_\\theta (s)))$$\n",
    "\n",
    "\n",
    "Please note the `-` sign. We need to do gradient ascent but PyTorch does gradient descent. We convert the ascent to descent using a -ve sign. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_policy_loss(agent, states):\n",
    "    \n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, dtype=torch.float)\n",
    "    \n",
    "    q1_values = agent.q1(states, agent.policy(states))\n",
    "    \n",
    "    loss_policy = - q1_values.mean()\n",
    "    \n",
    "    return loss_policy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One step gradient Descent on both Policy(Actor) and Q-value(Critic)\n",
    "\n",
    "The policy update is delayed. It is updated every `policy_delay` updates of Q updates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_step_update(agent, target_network, q_params, q_optimizer, policy_optimizer, \n",
    "                    states, actions, rewards, next_states, done_flags,\n",
    "                    gamma, polyak, target_noise, noise_clip, act_limit, \n",
    "                    policy_delay, timer):\n",
    "    \n",
    "    #one step gradient for q-values\n",
    "    q_optimizer.zero_grad()\n",
    "    loss_q = compute_q_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma, target_noise, noise_clip, act_limit)\n",
    "    loss_q.backward()\n",
    "    q_optimizer.step()\n",
    "    \n",
    "    # Update policy and target networks after policy_delay updates of Q-networks\n",
    "    if timer % policy_delay == 0:\n",
    "        #Freeze Q-network\n",
    "        for params in q_params:\n",
    "            params.requires_grad = False\n",
    "\n",
    "        #one setep gradient for policy network\n",
    "        policy_optimizer.zero_grad()\n",
    "        loss_policy = compute_policy_loss(agent, states)\n",
    "        loss_policy.backward()\n",
    "        policy_optimizer.step()\n",
    "\n",
    "        #UnFreeze Q-network\n",
    "        for params in q_params:\n",
    "            params.requires_grad = True\n",
    "\n",
    "\n",
    "        # update target networks with polyak averaging\n",
    "        with torch.no_grad():\n",
    "            for params, params_target in zip(agent.parameters(), target_network.parameters()):\n",
    "                params_target.data.mul_(polyak)\n",
    "                params_target.data.add_((1-polyak)*params.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To Test performance of agent without any noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_agent(env, agent, num_test_episodes, max_ep_len):\n",
    "    ep_rets, ep_lens = [], []\n",
    "    for j in range(num_test_episodes):\n",
    "        state, done, ep_ret, ep_len = env.reset(), False, 0, 0\n",
    "        while not(done or (ep_len == max_ep_len)):\n",
    "            # Take deterministic actions at test time (noise_scale=0)\n",
    "            state, reward, done, _ = env.step(agent.get_action(state, 0))\n",
    "            ep_ret += reward\n",
    "            ep_len += 1\n",
    "        ep_rets.append(ep_ret)\n",
    "        ep_lens.append(ep_len)\n",
    "    return np.mean(ep_rets), np.mean(ep_lens)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TD3 Algorithm\n",
    "\n",
    "We pull all the pieces together to train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def td3(env_fn, seed=0, \n",
    "         steps_per_epoch=4000, epochs=5, replay_size=int(1e6), gamma=0.99, \n",
    "         polyak=0.995, policy_lr=1e-3, q_lr=1e-3, batch_size=100, start_steps=10000, \n",
    "         update_after=1000, update_every=50, act_noise=0.1, target_noise=0.2,\n",
    "         noise_clip=0.5, policy_delay=2, num_test_episodes=10, max_ep_len=1000):\n",
    "    \n",
    "    torch.manual_seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    env, test_env = env_fn(), env_fn()\n",
    "    \n",
    "    ep_rets, ep_lens = [], []\n",
    "\n",
    "    state_dim = env.observation_space.shape\n",
    "    act_dim = env.action_space.shape[0]\n",
    "    \n",
    "    act_limit = env.action_space.high[0]\n",
    "    \n",
    "    agent = MLPActorCritic(env.observation_space, env.action_space)\n",
    "    target_network = deepcopy(agent)\n",
    "    \n",
    "    \n",
    "    # Freeze target networks with respect to optimizers (only update via polyak averaging)\n",
    "    for params in target_network.parameters():\n",
    "        params.requires_grad = False\n",
    "    \n",
    "    \n",
    "    # Experience buffer\n",
    "    replay_buffer = ReplayBuffer(replay_size)\n",
    "    \n",
    "    # List of parameters for both Q-networks \n",
    "    q_params = itertools.chain(agent.q1.parameters(), agent.q2.parameters())\n",
    "\n",
    "    #optimizers\n",
    "    q_optimizer = Adam(q_params, lr=q_lr)\n",
    "    policy_optimizer = Adam(agent.policy.parameters(), lr=policy_lr)\n",
    "    \n",
    "    total_steps = steps_per_epoch*epochs\n",
    "    state, ep_ret, ep_len = env.reset(), 0, 0\n",
    "    \n",
    "    for t in range(total_steps):\n",
    "        if t > start_steps:\n",
    "            action = agent.get_action(state, act_noise)\n",
    "        else:\n",
    "            action = env.action_space.sample()\n",
    "            \n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        ep_ret += reward\n",
    "        ep_len += 1\n",
    "        \n",
    "        # Ignore the \"done\" signal if it comes from hitting the time\n",
    "        # horizon (that is, when it's an artificial terminal signal\n",
    "        # that isn't based on the agent's state)\n",
    "        done = False if ep_len==max_ep_len else done\n",
    "        \n",
    "        # Store experience to replay buffer\n",
    "        replay_buffer.add(state, action, reward, next_state, done)\n",
    "        \n",
    "        state = next_state\n",
    "        \n",
    "        # End of trajectory handling\n",
    "        if done or (ep_len == max_ep_len):\n",
    "            ep_rets.append(ep_ret)\n",
    "            ep_lens.append(ep_len)\n",
    "            state, ep_ret, ep_len = env.reset(), 0, 0\n",
    "        \n",
    "        # Update handling\n",
    "        if t >= update_after and t % update_every == 0:\n",
    "            for j in range(update_every):\n",
    "                states, actions, rewards, next_states, done_flags = replay_buffer.sample(batch_size)\n",
    "                \n",
    "                one_step_update(\n",
    "                        agent, target_network, q_params, q_optimizer, policy_optimizer, \n",
    "                        states, actions, rewards, next_states, done_flags,\n",
    "                        gamma, polyak, target_noise, noise_clip, act_limit, policy_delay, j\n",
    "                )\n",
    "        \n",
    "        # End of epoch handling\n",
    "        if (t+1) % steps_per_epoch == 0:\n",
    "            epoch = (t+1) // steps_per_epoch\n",
    "            \n",
    "            avg_ret, avg_len = test_agent(test_env, agent, num_test_episodes, max_ep_len)\n",
    "            print(\"End of epoch: {:.0f}, Training Average Reward: {:.0f}, Training Average Length: {:.0f}\".format(epoch, np.mean(ep_rets), np.mean(ep_lens)))\n",
    "            print(\"End of epoch: {:.0f}, Test Average Reward: {:.0f}, Test Average Length: {:.0f}\".format(epoch, avg_ret, avg_len))\n",
    "            ep_rets, ep_lens = [], []\n",
    "    \n",
    "    return agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of epoch: 1, Training Average Reward: -6464, Training Average Length: 1000\n",
      "End of epoch: 1, Test Average Reward: -3820, Test Average Length: 1000\n",
      "End of epoch: 2, Training Average Reward: -5504, Training Average Length: 1000\n",
      "End of epoch: 2, Test Average Reward: -167, Test Average Length: 1000\n",
      "End of epoch: 3, Training Average Reward: -4196, Training Average Length: 1000\n",
      "End of epoch: 3, Test Average Reward: -121, Test Average Length: 1000\n",
      "End of epoch: 4, Training Average Reward: -120, Training Average Length: 1000\n",
      "End of epoch: 4, Test Average Reward: -98, Test Average Length: 1000\n",
      "End of epoch: 5, Training Average Reward: -151, Training Average Length: 1000\n",
      "End of epoch: 5, Test Average Reward: -144, Test Average Length: 1000\n"
     ]
    }
   ],
   "source": [
    "env_name = 'Pendulum-v0'\n",
    "agent = td3(lambda : make_env(env_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_animation(env, agent, save_dir):\n",
    "    \n",
    "    try:\n",
    "        env = gym.wrappers.Monitor(\n",
    "            env, save_dir, video_callable=lambda id: True, force=True, mode='evaluation')\n",
    "    except gym.error.Error as e:\n",
    "        print(e)\n",
    "\n",
    "    if not os.path.exists(save_dir):\n",
    "        os.makedirs(save_dir)\n",
    "        \n",
    "    state, done, ep_ret, ep_len = env.reset(), False, 0, 0\n",
    "    while not done:\n",
    "        # Take deterministic actions at test time (noise_scale=0)\n",
    "        state, reward, done, _ = env.step(agent.get_action(state, 0))\n",
    "        ep_ret += reward\n",
    "        ep_len += 1\n",
    "\n",
    "    print('Reward: {}'.format(ep_ret))\n",
    "    env.close()\n",
    "            \n",
    "def display_animation(filepath):\n",
    "    video = io.open(filepath, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    return HTML(data='''<video alt=\"test\" controls>\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "                 </video>'''.format(encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reward: -2.2673474324853355\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Animate learned policy\n",
    "save_dir='./videos/pytorch/td3/pendulum'\n",
    "env = gym.make(env_name)\n",
    "generate_animation(env, agent, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train and evaluate performance on LunarLander Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of epoch: 1, Training Average Reward: -211, Training Average Length: 108\n",
      "End of epoch: 1, Test Average Reward: -278, Test Average Length: 117\n",
      "End of epoch: 2, Training Average Reward: -190, Training Average Length: 109\n",
      "End of epoch: 2, Test Average Reward: 48, Test Average Length: 378\n",
      "End of epoch: 3, Training Average Reward: -179, Training Average Length: 145\n",
      "End of epoch: 3, Test Average Reward: -100, Test Average Length: 510\n",
      "End of epoch: 4, Training Average Reward: -217, Training Average Length: 669\n",
      "End of epoch: 4, Test Average Reward: -229, Test Average Length: 415\n",
      "End of epoch: 5, Training Average Reward: -84, Training Average Length: 323\n",
      "End of epoch: 5, Test Average Reward: -29, Test Average Length: 324\n",
      "Reward: 8.444013142371816\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Train\n",
    "env_name = 'LunarLanderContinuous-v2'\n",
    "agent1 = td3(lambda : make_env(env_name))\n",
    "\n",
    "# Animate learned policy\n",
    "save_dir='./videos/pytorch/td3/lunar'\n",
    "env = gym.make(env_name)\n",
    "generate_animation(env, agent1, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
